TypeScript autentifikavimas: JWT tipų saugumo modeliai globalioms programoms

Šiuolaikiniame tarpusavyje susijusiame pasaulyje saugių ir patikimų globalių programų kūrimas yra ypač svarbus. Autentifikavimas – procesas, kurio metu patvirtinama vartotojo tapatybė – atlieka lemiamą vaidmenį saugant jautrius duomenis ir užtikrinant autorizuotą prieigą. JSON Web Tokenai (JWT) tapo populiariu pasirinkimu autentifikavimui įgyvendinti dėl savo paprastumo ir perkeliamumo. Sujungus su galinga TypeScript tipų sistema, JWT autentifikavimas gali tapti dar tvirtesnis ir lengviau prižiūrimas, ypač didelio masto, tarptautiniuose projektuose.

Kodėl naudoti TypeScript JWT autentifikavimui?

TypeScript suteikia keletą pranašumų kuriant autentifikavimo sistemas:

• Tipų saugumas: TypeScript statinis tipavimas padeda anksti aptikti klaidas kūrimo procese, mažindamas netikėtumų vykdymo metu riziką. Tai ypač svarbu saugumui jautriems komponentams, tokiems kaip autentifikavimas.
• Geresnis kodo palaikymas: Tipai suteikia aiškias sutartis ir dokumentaciją, todėl lengviau suprasti, modifikuoti ir refaktorizuoti kodą, ypač sudėtingose globaliose programose, kuriose gali dalyvauti keli programuotojai.
• Patobulintas kodo užbaigimas ir įrankiai: TypeScript palaikančios IDE siūlo geresnį kodo užbaigimą, naršymą ir refaktorizavimo įrankius, didindamos programuotojų produktyvumą.
• Mažiau pasikartojančio kodo: Funkcijos, tokios kaip sąsajos (interfaces) ir apibendrintieji tipai (generics), padeda sumažinti pasikartojančio kodo kiekį ir pagerinti kodo pakartotinį panaudojamumą.

JWT supratimas

JWT yra kompaktiškas, URL saugus būdas pavaizduoti teiginius (claims), perduodamus tarp dviejų šalių. Jį sudaro trys dalys:

1. Antraštė (Header): Nurodo algoritmą ir rakto tipą.
2. Turinys (Payload): Sudėtyje yra teiginiai, tokie kaip vartotojo ID, rolės ir galiojimo laikas.
3. Parašas (Signature): Užtikrina rakto vientisumą naudojant slaptą raktą.

JWT paprastai naudojami autentifikavimui, nes juos galima lengvai patikrinti serverio pusėje, nereikalaujant duomenų bazės užklausos kiekvienam prašymui. Tačiau saugoti jautrią informaciją tiesiogiai JWT turinyje paprastai nerekomenduojama.

Tipų saugumo JWT autentifikavimo įgyvendinimas TypeScript kalboje

Panagrinėkime keletą modelių, kaip sukurti tipų saugumo JWT autentifikavimo sistemas naudojant TypeScript.

1. Turinys tipų apibrėžimas naudojant sąsajas (Interfaces)

Pradėkite nuo sąsajos, kuri apibrėžia jūsų JWT turinio struktūrą. Tai užtikrins tipų saugumą, kai pasieksite teiginius rakto viduje.

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  iat: number; // Išdavimo laikas (laiko žyma)
  exp: number; // Galiojimo pabaigos laikas (laiko žyma)
}

Ši sąsaja apibrėžia laukiamą JWT turinio formą. Įtraukėme standartinius JWT teiginius, tokius kaip `iat` (išdavimo laikas) ir `exp` (galiojimo laikas), kurie yra svarbūs rakto galiojimo valdymui. Galite pridėti bet kokių kitų jūsų programai aktualių teiginių, pavyzdžiui, vartotojo roles ar leidimus. Gera praktika yra apriboti teiginius tik būtina informacija, kad sumažintumėte rakto dydį ir padidintumėte saugumą.

Pavyzdys: Vartotojų rolių valdymas globalioje el. prekybos platformoje

Įsivaizduokite el. prekybos platformą, aptarnaujančią klientus visame pasaulyje. Skirtingi vartotojai turi skirtingas roles:

• Administratorius (Admin): Pilna prieiga valdyti produktus, vartotojus ir užsakymus.
• Pardavėjas (Seller): Gali pridėti ir valdyti savo produktus.
• Klientas (Customer): Gali naršyti ir pirkti produktus.

`roles` masyvas `JwtPayload` sąsajoje gali būti naudojamas šioms rolėms pavaizduoti. Galėtumėte išplėsti `roles` savybę į sudėtingesnę struktūrą, detaliai aprašančią vartotojo prieigos teises. Pavyzdžiui, galėtumėte turėti šalių sąrašą, kuriose vartotojas gali veikti kaip pardavėjas, arba parduotuvių masyvą, prie kurių vartotojas turi administratoriaus prieigą.

2. Tipizuotos JWT tarnybos kūrimas

Sukurkite tarnybą, kuri tvarkytų JWT kūrimą ir tikrinimą. Ši tarnyba turėtų naudoti `JwtPayload` sąsają, kad užtikrintų tipų saugumą.

import jwt from 'jsonwebtoken';

const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key'; // Saugokite saugiai!

class JwtService {
  static sign(payload: Omit, expiresIn: string = '1h'): string {
    const now = Math.floor(Date.now() / 1000);
    const payloadWithTimestamps: JwtPayload = {
        ...payload,
        iat: now,
        exp: now + parseInt(expiresIn) * 60 * 60,
    };
    return jwt.sign(payloadWithTimestamps, JWT_SECRET);
  }

  static verify(token: string): JwtPayload | null {
    try {
      const decoded = jwt.verify(token, JWT_SECRET) as JwtPayload;
      return decoded;
    } catch (error) {
      console.error('JWT verification error:', error);
      return null;
    }
  }
}

Ši tarnyba teikia du metodus:

• `sign()`: Sukuria JWT iš turinio. Ji priima `Omit`, kad užtikrintų, jog `iat` ir `exp` yra generuojami automatiškai. Svarbu saugiai laikyti `JWT_SECRET`, idealiai naudojant aplinkos kintamuosius ir paslapčių valdymo sprendimus.
• `verify()`: Patikrina JWT ir grąžina dekoduotą turinį, jei jis galioja, arba `null`, jei negalioja. Po patikrinimo naudojame tipo patvirtinimą `as JwtPayload`, kuris yra saugus, nes `jwt.verify` metodas arba išmeta klaidą (sugaunamą `catch` bloke), arba grąžina objektą, atitinkantį mūsų apibrėžtą turinio struktūrą.

Svarbūs saugumo aspektai:

• Slapto rakto valdymas: Niekada nekoduokite savo JWT slapto rakto tiesiogiai kode. Naudokite aplinkos kintamuosius arba specializuotą paslapčių valdymo tarnybą. Reguliariai keiskite raktus.
• Algoritmo pasirinkimas: Pasirinkite stiprų pasirašymo algoritmą, pavyzdžiui, HS256 arba RS256. Venkite silpnų algoritmų, tokių kaip `none`.
• Rakto galiojimo laikas: Nustatykite tinkamus JWT galiojimo laikus, kad apribotumėte kompromituotų raktų poveikį.
• Rakto saugojimas: Saugiai laikykite JWT kliento pusėje. Galimybės apima HTTP-only slapukus arba vietinę saugyklą (local storage) su atitinkamomis atsargumo priemonėmis prieš XSS atakas.

3. API galinių punktų apsauga su tarpine programine įranga (Middleware)

Sukurkite tarpinę programinę įrangą, kad apsaugotumėte savo API galinius punktus, tikrindami JWT `Authorization` antraštėje.

import { Request, Response, NextFunction } from 'express';

interface RequestWithUser extends Request {
  user?: JwtPayload;
}

function authenticate(req: RequestWithUser, res: Response, next: NextFunction) {
  const authHeader = req.headers.authorization;

  if (!authHeader) {
    return res.status(401).json({ message: 'Neautorizuota' });
  }

  const token = authHeader.split(' ')[1]; // Daroma prielaida, kad tai „Bearer“ tipo raktas
  const decoded = JwtService.verify(token);

  if (!decoded) {
    return res.status(401).json({ message: 'Netinkamas raktas' });
  }

  req.user = decoded;
  next();
}

export default authenticate;

Ši tarpinė programinė įranga ištraukia JWT iš `Authorization` antraštės, patikrina jį naudojant `JwtService` ir prideda dekoduotą turinį prie `req.user` objekto. Taip pat apibrėžiame `RequestWithUser` sąsają, kad išplėstume standartinę `Request` sąsają iš Express.js, pridedant `user` savybę, kurios tipas yra `JwtPayload | undefined`. Tai suteikia tipų saugumą, kai pasiekiama vartotojo informacija apsaugotuose maršrutuose.

Pavyzdys: Laiko juostų valdymas globalioje programoje

Įsivaizduokite, kad jūsų programa leidžia vartotojams iš skirtingų laiko juostų planuoti įvykius. Galbūt norėsite saugoti vartotojo pageidaujamą laiko juostą JWT turinyje, kad teisingai rodytumėte įvykių laikus. Galėtumėte pridėti `timeZone` teiginį į `JwtPayload` sąsają:

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  timeZone: string; // pvz., 'America/Los_Angeles', 'Asia/Tokyo'
  iat: number;
  exp: number;
}

Tada savo tarpinėje programinėje įrangoje arba maršrutų apdorojimo funkcijose galite pasiekti `req.user.timeZone`, kad formatuotumėte datas ir laikus pagal vartotojo pageidavimus.

4. Autentifikuoto vartotojo naudojimas maršrutų apdorojimo funkcijose

Savo apsaugotų maršrutų apdorojimo funkcijose dabar galite pasiekti autentifikuoto vartotojo informaciją per `req.user` objektą su visišku tipų saugumu.

import express, { Request, Response } from 'express';
import authenticate from './middleware/authenticate';

const app = express();

app.get('/profile', authenticate, (req: Request, res: Response) => {
  const user = (req as any).user; // arba naudokite RequestWithUser
  res.json({ message: `Sveiki, ${user.email}!`, userId: user.userId });
});

Šis pavyzdys parodo, kaip pasiekti autentifikuoto vartotojo el. pašto adresą ir ID iš `req.user` objekto. Kadangi apibrėžėme `JwtPayload` sąsają, TypeScript žino laukiamą `user` objekto struktūrą ir gali suteikti tipų tikrinimą bei kodo užbaigimą.

5. Rolemis pagrįstos prieigos kontrolės (RBAC) įgyvendinimas

Norėdami gauti smulkesnę prieigos kontrolę, galite įgyvendinti RBAC, pagrįstą JWT turinyje saugomomis rolėmis.

function authorize(roles: string[]) {
  return (req: RequestWithUser, res: Response, next: NextFunction) => {
    const user = req.user;

    if (!user || !user.roles.some(role => roles.includes(role))) {
      return res.status(403).json({ message: 'Uždrausta' });
    }

    next();
  };
}

Ši `authorize` tarpinė programinė įranga tikrina, ar vartotojo rolės apima bent vieną iš reikalaujamų rolių. Jei ne, grąžinama 403 Forbidden klaida.

app.get('/admin', authenticate, authorize(['admin']), (req: Request, res: Response) => {
  res.json({ message: 'Sveiki, Administratoriau!' });
});

Šis pavyzdys apsaugo `/admin` maršrutą, reikalaujant, kad vartotojas turėtų `admin` rolę.

Pavyzdys: Skirtingų valiutų valdymas globalioje programoje

Jei jūsų programa tvarko finansines operacijas, gali prireikti palaikyti kelias valiutas. Galėtumėte saugoti vartotojo pageidaujamą valiutą JWT turinyje:

interface JwtPayload {
  userId: string;
  email: string;
  roles: string[];
  currency: string; // pvz., 'USD', 'EUR', 'JPY'
  iat: number;
  exp: number;
}

Tada savo serverio logikoje galite naudoti `req.user.currency` kainoms formatuoti ir atlikti valiutų konversijas pagal poreikį.

6. Atnaujinimo raktai (Refresh Tokens)

JWT pagal savo prigimtį yra trumpalaikiai. Kad nereikėtų vartotojams dažnai prisijungti, įdiekite atnaujinimo raktus. Atnaujinimo raktas yra ilgalaikis raktas, kurį galima naudoti naujam prieigos raktui (JWT) gauti, nereikalaujant, kad vartotojas iš naujo įvestų savo prisijungimo duomenis. Saugiai laikykite atnaujinimo raktus duomenų bazėje ir susiekite juos su vartotoju. Kai vartotojo prieigos raktas nustoja galioti, jis gali naudoti atnaujinimo raktą, kad paprašytų naujo. Šis procesas turi būti įgyvendintas atsargiai, kad būtų išvengta saugumo pažeidžiamumų.

Pažangios tipų saugumo technikos

1. Diskriminuotosios sąjungos (Discriminated Unions) smulkesnei kontrolei

Kartais jums gali prireikti skirtingų JWT turinių, priklausomai nuo vartotojo rolės ar užklausos tipo. Diskriminuotosios sąjungos gali padėti tai pasiekti su tipų saugumu.

interface AdminJwtPayload {
  type: 'admin';
  userId: string;
  email: string;
  roles: string[];
  iat: number;
  exp: number;
}

interface UserJwtPayload {
  type: 'user';
  userId: string;
  email: string;
  iat: number;
  exp: number;
}

type JwtPayload = AdminJwtPayload | UserJwtPayload;

function processToken(payload: JwtPayload) {
  if (payload.type === 'admin') {
    console.log('Admin email:', payload.email); // Saugiai galima pasiekti el. paštą
  } else {
    // payload.email čia nepasiekiamas, nes tipas yra 'user'
    console.log('User ID:', payload.userId);
  }
}

Šis pavyzdys apibrėžia du skirtingus JWT turinio tipus, `AdminJwtPayload` ir `UserJwtPayload`, ir sujungia juos į diskriminuotąją sąjungą `JwtPayload`. `type` savybė veikia kaip diskriminatorius, leidžiantis saugiai pasiekti savybes pagal turinio tipą.

2. Apibendrintieji tipai (Generics) pakartotinai naudojamai autentifikavimo logikai

Jei turite kelias autentifikavimo schemas su skirtingomis turinio struktūromis, galite naudoti apibendrintuosius tipus, kad sukurtumėte pakartotinai naudojamą autentifikavimo logiką.

interface BaseJwtPayload {
  userId: string;
  iat: number;
  exp: number;
}

function verifyToken(token: string): T | null {
  try {
    const decoded = jwt.verify(token, JWT_SECRET) as T;
    return decoded;
  } catch (error) {
    console.error('JWT verification error:', error);
    return null;
  }
}

const adminToken = verifyToken('admin-token');
if (adminToken) {
  console.log('Admin email:', adminToken.email);
}

Šis pavyzdys apibrėžia `verifyToken` funkciją, kuri priima bendrinį tipą `T`, išplečiantį `BaseJwtPayload`. Tai leidžia jums tikrinti raktus su skirtingomis turinio struktūromis, užtikrinant, kad visi jie turėtų bent jau `userId`, `iat` ir `exp` savybes.

Globalių programų aspektai

Kuriant autentifikavimo sistemas globalioms programoms, atsižvelkite į šiuos dalykus:

• Lokalizacija: Užtikrinkite, kad klaidų pranešimai ir vartotojo sąsajos elementai būtų lokalizuoti skirtingoms kalboms ir regionams.
• Laiko juostos: Teisingai tvarkykite laiko juostas, nustatydami raktų galiojimo laikus ir rodydami datas bei laikus vartotojams.
• Duomenų privatumas: Laikykitės duomenų privatumo taisyklių, tokių kaip GDPR ir CCPA. Sumažinkite asmeninių duomenų kiekį, saugomą JWT.
• Prieinamumas: Kurkite autentifikavimo procesus taip, kad jie būtų prieinami vartotojams su negalia.
• Kultūrinis jautrumas: Būkite atidūs kultūriniams skirtumams, kurdami vartotojo sąsajas ir autentifikavimo procesus.

Išvada

Pasitelkdami TypeScript tipų sistemą, galite sukurti tvirtas ir lengvai prižiūrimas JWT autentifikavimo sistemas globalioms programoms. Turinys tipų apibrėžimas naudojant sąsajas, tipizuotų JWT tarnybų kūrimas, API galinių punktų apsauga su tarpine programine įranga ir RBAC įgyvendinimas yra esminiai žingsniai užtikrinant saugumą ir tipų saugumą. Atsižvelgdami į globalių programų aspektus, tokius kaip lokalizacija, laiko juostos, duomenų privatumas, prieinamumas ir kultūrinis jautrumas, galite sukurti įtraukiančias ir vartotojui draugiškas autentifikavimo patirtis įvairialypei tarptautinei auditorijai. Visada prisiminkite teikti pirmenybę geriausioms saugumo praktikoms dirbant su JWT, įskaitant saugų raktų valdymą, algoritmo pasirinkimą, rakto galiojimo laiką ir rakto saugojimą. Išnaudokite TypeScript galią kurti saugias, keičiamo dydžio ir patikimas autentifikavimo sistemas savo globalioms programoms.